// pages/Member/member_Coupon/member_Cop_Available/member_Cop_Available.js


/**
 * 此页面的逻辑：---------------------------------------------------
 * 1. tab只显示 XX抵用券  XX停车券，如果以后有其他的，则增加tab的数组内容。
 * 2. 抵用券下显示所有性质的抵用券（如：定额抵用券、折扣抵用券）。
 * 3. 停车券下显示所有性质的停车券（如：定额停车券、市场停车券）。
 * 4. 列表的处理：
 *    4-1、分别请求不同性质的券得到不同的数组，如：A数组-定额停车券   B数组-时长停车券
 *    4-2、再把A B数组进行合并为C数组
 */

//获取应用实例(获取app.js全局变量必须获取应用实例)
const App = getApp()

//网络请求封装
import Request_post from "../../../../request/Request_post"
import Request_get from "../../../../request/Request_get"

//系统设置项目:(请求地址-在封装中已经引入，这里不需要;   api调用的Appid-partner_app_id;   渠道ID-as_appid)
import config from "../../../../config/config"

//引入时间函数
var dateArray = require("../../../../utils/CustomFunction/getDayFirstNowLast.js")
var time = require("../../../../utils/CustomFunction/getNowTime.js")

//引入日期时间：（格式化、反格式化）函数
var formatDate = require("../../../../utils/CustomFunction/dateFormat.js")
var unformatDate = require("../../../../utils/CustomFunction/dateUnFormat.js")

// 获取次月
var getNextMonth = require("../../../../utils/CustomFunction/getNextMonth.js")

//获取当前的日期时间 yyyy-mm-dd hh:mm:ss
var todayDatetTime = require("../../../../utils/CustomFunction/getNowDateTime.js")

// 获取当前的日期 yyyy-mm-dd
var getToday = require("../../../../utils/CustomFunction/getToday.js")

// 获取明天的日期 yyyy-mm-dd
var getTomorrow = require("../../../../utils/CustomFunction/getTomorrow.js")

//获取当前是周几
var getNowWeek = require("../../../../utils/CustomFunction/getNowWeek.js")

//日期时间（yyyy-mm-dd hh:mm:ss）转换为时间戳
var timeTostamp = require("../../../../utils/CustomFunction/timeTostamp.js")

//星期X 转换为 数值
var weekTonumber = require("../../../../utils/CustomFunction/weekTonumber.js")

// 将0开头的长度为2位的字符串转换为数值，如：  '02' 转为 2
var TwoStringToNumbser = require("../../../../utils/CustomFunction/TwoStringToNumbser.js")

//计算两个时间戳的差值，返回毫秒
var intervalTime = require("../../../../utils/CustomFunction/intervalTime.js")



//全局数组：优惠券样式
import wxGloalArray from "../../../../config/GlobalArray.js"

// 缓存rul图片到本地
import cacheimg from "../../../../utils/cacheImg"



Page({


  /**
   * 页面的初始数据
   *  
   */
  data: {


		// 浮动按钮的组件传参
		urlLink: "/pages/HomePage/Markeing_HomePage/Markeing_HomePage",
		buttonIcon: "../../../../image/toHome.png",
		buttonText: "返回首页",

    copShowlist: "true",

    // 页面外链资源图片（需要本地缓存的）
    pageImage: 
    [ 
      {key: "Default_shopping_logo",value: config.imageUrl+"Default_shopping_logo.jpg"},
      {key: "Default_parking_logo",value: config.imageUrl+"Default_parking_logo.jpg"},
      {key: "Default_exchang_logo",value: config.imageUrl+"Default_exchang_logo.jpg"},
      {key: "SoldOut",value: config.imageUrl+"SoldOut.png"},                  // 全部已售罄图片
      {key: "Cycle_SoldOut",value: config.imageUrl+"Cycle_SoldOut.png"},      // 本轮（周期）已售罄图片
      {key: "ownflg",value: config.imageUrl+"Ownflg.png"},                    // 业主专享图片
    ],

    // 显示倒计时的时间戳
		ShowCountdownStamp: App.globalData.ShowCountdownStamp,
		// 营销活动可购买剩余数量在页面上的显示上限
		ActshowVldqty: App.globalData.ActshowVldqty,

    
		index:0,
		selectIndex:0,
    
    
    coplist:[],

    /*定义一个临时数组(由于标签页数组Tabs_list是父组件传递给自定义组件的初始数据，而在onshow()中，是根据echmodid-领取方式，来初始构建Tabs_list的，而在构建数组之前)
      又需要循环此数组，用于其他页面路由到此页面时，根据index的值确定，点击的标签页，所以在Tabs_list还没有初始构建之前，有需要循环此数组的数据，所以需要定义一个临时数组*/
    list:
    [
      {name:"积分兑换抵用券",isActive:true},
      {name:"积分兑换停车券",isActive:false}
    ],

    //优惠券性质 默认初始值：抵用券-01
    copchtid:"01",

  },

  //未注册会员点击注册
  regNow:function(){
    wx.redirectTo({ 
      url:"/SubpkgPublicPage/pages/PublicPage/PrivacyPolicy/PolicyMain/PolicyMain"
    });
  },


  //接收标签页自定义组件，点击事件---子组件传递过来的参数
	handleItemChang(e){
    var that = this

		const index = e.detail.index;
		const Tabs_list = that.data.Tabs_list;
		//方式一：使用forEach 遍历数组，遍历数组的时候，修改了v，也会导致源数组被修改
		Tabs_list.forEach((v,i)=>i===index? v.isActive=true:v.isActive=false);
		//方式二：使用for循环
		// for(var n = 0; n < tabs.length; n++){
		// 	n === index? tabs[n].isActive=true:tabs[n].isActive=false
		// }
		that.setData({
			Tabs_list:Tabs_list,
			index:index,
			selectIndex:index
    })

    if(that.data.selectIndex == 0){
      that.setData({
        copchtid:"01"   //01- 抵用券
      })
      that.onShow()       //切换标签后，再此请求onShow函数（主要是通过切换标签获得不同的copchtid）
    }else if(that.data.selectIndex == 1){
      that.setData({
        copchtid:"09,10"   // 09- 停车券（包含09-定额停车券 & 10-时长停车券）
      })
			that.onShow()       //切换标签后，再此请求onShow函数（主要是通过切换标签获得不同的copchtid）
			that.parkingCop_showModal();
    }
    // console.log(that.data.selectIndex)
		// console.log(that.data.Tabs_list)
  },
    

  /** 外链图片Url资源，缓存到本地 */
	storeImage:function(){
    var that = this
    let obj = {}
    let pageimgArr = that.data.pageImage
    // 图片外链url：ip:端口 替换成 域名（外链资源不做域名转换了，而是外链资源原始链接必须就是域名url）
    // pageimgArr.forEach(i => {i.value = config.domainName + i.value.split('/').slice(3).join('/')})
    // 调用本地文件缓存方法 mapCacheUrl
    pageimgArr = pageimgArr.map(i => ({
      ...i,imgpath:cacheimg.mapCacheUrl(i.value)
    }))  
    // 数组转换为对象
    pageimgArr.forEach(i => {obj[i.key] = i.imgpath})
    that.setData({pageStoreimg: obj })
    // console.log(that.data.pageStoreimg)
  },
  

  // 延时处理
  // Delay:function(){
  //   var that = this
  //   setTimeout(function(){
  //     console.log(App.globalData.mbrid)
  //     if(!App.globalData.mbrid){
  //       wx.redirectTo({
  //         url: App.globalData.homePage,
  //       })
  //     }
  //   },5000)
  // },


  /** 外部链接直接跳转到本页面，将参数保存为全局变量（因为本页面需要携带参数进入） */
  PageParm_handle:function(){
    var that = this
    if(that.data.opt_index && that.data.opt_echmodid){
      App.globalData.Scenepath_parameter = '?index='+that.data.opt_index+'&echmodid='+that.data.opt_echmodid
    }
    // if(App.globalData.Scenepath === '/SubpkgMarketing/pages/Coupon/IssueCopList/IssueCopList'){
    //   // 1. 判断小程序的进入路径是否是本页面，如果是，则把页面路径的参数，保存为全局变量：Scenepath_parameter
    //    App.globalData.Scenepath_parameter = '?index='+that.data.opt_index+'&echmodid='+that.data.opt_echmodid
    //    console.log(App.globalData.Scenepath_parameter)
    //   // 2. 判断本机是否有会员的信息缓存
    //   var mbrInfo = wx.getStorageSync('StrMbrInfo')
    //   if(!mbrInfo){
    //     wx.redirectTo({
    //       url: '/pages/index/index',
    //     })
    //   }
    // }
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    var that = this
    //  Step-1: 接收外部进入本页面携带的 index、echmodid 页面必须携带的参数 --（../mbmber_Itg_Center）
    var opt_echmodid = options.echmodid
    var opt_index = options.index
    that.setData({
      opt_echmodid,
			opt_index,
			FloatingButton:wx.getStorageSync('StrMktopt').FloatingButton
		})
		
		// 和谐定制弹窗
		if(opt_index == 1){
			that.parkingCop_showModal();
		}
    
    // 外部链接直接跳转到本页面，需要做的处理
    that.PageParm_handle()
    console.log(App.globalData.Scenepath_parameter)

    // 会员是否注册的标志regflg
    getApp().loginPromise.then(v => {	//app.js的Promise成功回调（全局变量赋值成功后才执行请求）
      that.setData({regflg: App.globalData.regflg})
    })
    // console.log(App.globalData.regflg)


    


    if( opt_index ){   //其他页面路由至此页面，同时还需要确定点击的标签页时，echmodid & index 数据，都需要从路由页面传递过来（如：积分兑换中心路由至积分兑换停车券列表，需要停车券标签被选中）
      if(opt_index == 0){ //其他页面路由至此页面的 抵用券标签时，设置券性质为 01-抵用券｛券性质copchtid做为 onShow的查询参数｝
        that.setData({
          copchtid: '01',
          echmodid: opt_echmodid,
          index:  opt_index,
          selectIndex: opt_index,
        })
      }else if(opt_index == 1){ //其他页面路由至此页面的停车券标签时，设置券性质为 09-定额停车券 & 10-时长停车券｛券性质copchtid做为 onShow函数的查询参数｝
        that.setData({
          copchtid: "09,10",
          echmodid: opt_echmodid,
          index:  opt_index,
          selectIndex: opt_index,
				})
				that.parkingCop_showModal()
      }
    }else{                   //未接收到options.index参数，说明是从券中心页面进入的该页面，只需要接收 echmodid 数据（copchtid默认为data的默认值）
      that.setData({
        echmodid:opt_echmodid,
        index: 0,
        selectIndex: 0,
      })
    }

    

    

   // Step-2: 根据获得的功能id（echmodid）重构Tabs数组
    if(that.data.echmodid == "02"){      // echmodid == "02" 微会员领取
      if(that.data.index == 0){
        that.setData({
          Tabs_list:[
            {name:"可领抵用券",isActive:true},
            {name:"可领停车券",isActive:false}
          ],
        })
      }else if(that.data.index == 1){
        that.setData({
          Tabs_list:[
            {name:"可领抵用券",isActive:false},
            {name:"可领停车券",isActive:true}
          ],
				})
      }
    }else if(that.data.echmodid == "06"){   // echmodid == "06" 积分兑换
      if(that.data.index == 0){
        that.setData({
          Tabs_list:[
            {name:"积分兑换抵用券",isActive:true},
            {name:"积分兑换停车券",isActive:false}
          ],
        })
      }else if(that.data.index == 1){
        that.setData({
          Tabs_list:[
            {name:"积分兑换抵用券",isActive:false},
            {name:"积分兑换停车券",isActive:true}
          ],
				})
      } 
    }else if(that.data.echmodid == "05"){   // echmodid == "02" 在线购买
      if(that.data.index == 0){
        that.setData({
          Tabs_list:[
            {name:"在线购抵用券",isActive:true},
            {name:"在线购停车券",isActive:false}
          ],
        })
      }else if(that.data.index == 1){
				that.setData({
					Tabs_list:[
						{name:"在线购抵用券",isActive:false},
						{name:"在线购停车券",isActive:true}
					],
				})
      } 
		}
		

		


	},

	
	
	parkingCop_showModal:function(){
		var parkCopListshowMoal = wx.getStorageSync('StrMktopt').parkCopListshowMoal
		if(parkCopListshowMoal && parkCopListshowMoal !== ""){
			console.log('提示')
			wx.showModal({
				title: "温馨提示",
				content: parkCopListshowMoal,
				showCancel: false,   //是否显示取消按钮
				confirmText:"我知道了",    //默认是“确定”
				success: function (res) {
					if (res.confirm) {    //点击确认
					}
				},
			})
		}else{
			console.log('不需要提示')
		}
		
	},





  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {


  },

  //优惠券列表按钮（查看详情）
  copList_button:function(e){
    var copchtid = e.currentTarget.dataset.copchtid
    var cycle = e.currentTarget.dataset.cycle
    var echmodid = e.currentTarget.dataset.echmodid
    var rulechvldmode = e.currentTarget.dataset.rulechvldmode
    var showstyle = e.currentTarget.dataset.showstyle
    var srcbllno = e.currentTarget.dataset.srcbllno
    var startuseamt = e.currentTarget.dataset.startuseamt
    wx.navigateTo({
      url: '/SubpkgMarketing/pages/Coupon/IssueCopDetails/IssueCopDetails?srcbllno='+srcbllno+'&startuseamt='+startuseamt+'&copchtid='+copchtid+'&showstyle='+showstyle+'&rulechVldmode='+rulechvldmode+'&echmodid='+echmodid+'&Cycle='+cycle
    })
    console.log('/SubpkgMarketing/pages/Coupon/IssueCopDetails/IssueCopDetails?srcbllno='+srcbllno+'&startuseamt='+startuseamt+'&copchtid='+copchtid+'&showstyle='+showstyle+'&rulechVldmode='+rulechvldmode+'&echmodid='+echmodid+'&Cycle='+cycle)
  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    var that = this
    var _mbrparams = wx.getStorageSync('StrMbrInfo').mbrparams

    // 外链资源图片链接 本地缓存
    if(App.globalData.ResourcesLink_Locstr === 'y'){
      that.storeImage();
    // 外链资源图片链接 直接读取url地址
    }else{
      let pageimgArr = that.data.pageImage
      let object = {}
      pageimgArr.forEach(i => {object[i.key] = i.value}) // 数组转换为对象
      that.setData({pageStoreimg: object })
      // console.log(that.data.pageStoreimg)
    }

    

    /** Api请求：10-001 会员可领/可购/可兑电子优惠券列表查询  **/
    getApp().loginPromise.then(v => {	//app.js的Promise成功回调（全局变量赋值成功后才执行请求）

      // 刷新redis[优惠券活动] 数据，正式版不用，而是由后台做调用，仅供测试使用
      that.refreshPromise = new Promise((v,t) =>{

        // 小程序Appid == 昆明奥博克时，直接用刷新redis数据库的活动列表，否则为项目环境时，不刷新，按正常的逻辑进行
        if(App.globalData.miniProgram_appid !== 'wxa08aa9f00b5ecf23'){
          /* 随便做一个Promise的成功通知，以便正式版发布，要注释掉下面的创建请求，（redis列表由后台服务创建），但这里为了测试做了一个Promise的嵌套，这个嵌套就不删了，保留着 */
          let value = true
          v(true)
        }else{
          /* 创建redis数据库的活动列表（测试专用）*/ 
          var _today = unformatDate.DatString(getToday.getToday())
          Request_get.get(
            config.domainName+"api_echcopact/echcopact-refresh",
            {actdat: _today},
            function(res){
              if(res){
                v(true)
                console.log('已刷新Redis活动列表数据')
              }
            } 
          )
        }
      })
      
      that.refreshPromise.then( v => {
        App.globalData.mbrclsid = wx.getStorageSync('StrMbrInfo').mbrclsid
        if(_mbrparams){
          // 可领券列表
          if(that.data.echmodid == '02'){
            // Api请求：[微服务] 优惠券活动-echcopac：003-会员可【直接领取】优惠券列表查询
            Request_post.post(
              config.domainName+"api_echcopact/getcopact-list",
              {
                copcltid: config.copcltid,
                copchtid: that.data.copchtid,
                mbrparams: _mbrparams
              },
              function(res){
                // console.log('微服务列表[02-可领优惠券]',res)
                if(res != 'undefined' && res.return_no == 1 ){ 
                  if( res.return_data.copList.length > 0 ){
                    // 判断是否需要缓存下载，同时增加页面渲染的imgpath属性
                    if(App.globalData.Erpimage_Locstr ==='y'){
                      console.log('图片缓存到本地')
                      //将回调结果中的imgurl地址，转换为域名（原地址为：http://ip:port/xxx 转换为：https://域名/xxx）
                      let array = res.return_data.copList
                      for(var i in array){
                        if(array[i].logo){
                          array[i].logo = config.domainName + array[i].logo.split('/').slice(3).join('/');
                        }
                      }
                      // 调用本地文件缓存方法 mapCacheUrl
                      that.setData({
                        AvailableArray:array.map(i => ({
                          ...i,
                          imgpath:cacheimg.mapCacheUrl(i.logo)
                        }))  
                      }) ;
                    }else{
                      // 使用res的原始回调（数组对象中增加一个imgpath的属性值，因为html标签中用imgpath做渲染）
                      that.setData({
                        AvailableArray:res.return_data.copList.map(i => ({
                          ...i,
                          imgpath:i.logo
                        }))  ,
                      })
                    }
                    // console.log(that.data.AvailableArray)
                    // 循环判断当前会员的使用门槛金额，并重构数组
                    const AvailablecopArray = that.data.AvailableArray
                    
                    AvailablecopArray.forEach(item => {
                      item.startuseamt = item.cusscpList.find(i=> i.cusscpid == App.globalData.mbrclsid).usestdamt
                    });
                    that.setData({Coplist:AvailablecopArray})
                    // 根据券性质copchtid 赋值config/GlobalArray.js中的主题颜色 Begin
                    const List = that.data.Coplist
                    const style = wxGloalArray.copstyle
                    for(var i = 0; i < List.length; i++){
                      for(var e = 0; e < style.length; e++){
                        if(style[e].copchtid == List[i].copchtid){   // 券性质（01-抵用券、02-兑换券、09-定额停车券、10-时长停车券）
                          for(var key in style[e]){			             // 将style数组中的第n个对象的所有属性(值)添加到coparray数组的第i个对象中。
                            List[i][key] = style[e][key]
                          }
                        }
                      } 
                    }
                    that.setData({
                      Coplist:List,
                      copShowlist: "false"
                    })

                    //发券效期时段、的数据绑定逻辑处理
                    that.copTimelimitvld();

                    console.log(that.data.Coplist)
                  }else{
                    // 活动为空，直接赋值给Coplist，页面获取Coplist.length == 0 则渲染 “暂无相关活动”
                    that.setData({
                      Coplist: res.return_data.copList,
                      copShowlist: "false"
                    })

                  }
                }else{
                  that.setData({
                    copShowlist: "false"
                  })
                  wx.showModal({
                    content: res.return_msg,
                    showCancel: false,		//是否显示取消按钮
                    cancelColor:'skyblue',		//取消文字的颜色
                    confirmText:"确认",		//默认是“确定”
                    confirmColor: 'skyblue',	//确定文字的颜色
                  })
                }
              }
            )
          }
          // 可兑券列表
          else if(that.data.echmodid == '06'){
            // Api请求：[微服务] 优惠券活动-echcopac：005-会员可【积分兑换】优惠券列表查询
            Request_post.post(
              config.domainName+"api_echcopact/itgcopact-list",
              {
                copcltid: config.copcltid,
                copchtid: that.data.copchtid,
                mbrparams: _mbrparams
              },
              function(res){
                // console.log(res)
                if(res != 'undefined' && res.return_no == 1 ){ 
                  if( res.return_data.copList.length > 0 ){
                    // console.log(res)
                    // 判断是否需要缓存下载，同时增加页面渲染的imgpath属性
                    if(App.globalData.Erpimage_Locstr ==='y'){
                      console.log('图片缓存到本地')
                      //将回调结果中的imgurl地址，转换为域名（原地址为：http://ip:port/xxx 转换为：https://域名/xxx）
                      let array = res.return_data.copList
                      for(var i in array){
                        if(array[i].logo){
                          array[i].logo = config.domainName + array[i].logo.split('/').slice(3).join('/');
                        }
                      }
                      // 调用本地文件缓存方法 mapCacheUrl
                      that.setData({
                        AvailableArray:array.map(i => ({
                          ...i,
                          imgpath:cacheimg.mapCacheUrl(i.logo)
                        }))  
                      }) ;
                    }else{
                      // 使用res的原始回调（数组对象中增加一个imgpath的属性值，因为html标签中用imgpath做渲染）
                      that.setData({
                        AvailableArray:res.return_data.copList.map(i => ({
                          ...i,
                          imgpath:i.logo
                        }))  ,
                      })
                    }
                    // console.log(that.data.AvailableArray)

                    // 循环判断当前会员的使用门槛金额，并重构数组
                    const AvailablecopArray = that.data.AvailableArray
                    AvailablecopArray.forEach(item => {
                      item.startuseamt = item.cusscpList.find(i=> i.cusscpid == App.globalData.mbrclsid).usestdamt
                    });
                    that.setData({Coplist:AvailablecopArray})
                    console.log(that.data.Coplist)

                    // 根据券性质copchtid 赋值config/GlobalArray.js中的主题颜色 Begin
                    const List = that.data.Coplist
                    const style = wxGloalArray.copstyle
                    for(var i = 0; i < List.length; i++){
                      for(var e = 0; e < style.length; e++){
                        if(style[e].copchtid == List[i].copchtid){   // 券性质（01-抵用券、02-兑换券、09-定额停车券、10-时长停车券）
                          for(var key in style[e]){			             // 将style数组中的第n个对象的所有属性(值)添加到coparray数组的第i个对象中。
                            List[i][key] = style[e][key]
                          }
                        }
                      } 
                    }
                    that.setData({
                      Coplist:List,
                      copShowlist: "false"
                    })
                    //发券效期时段、的数据绑定逻辑处理
                    that.copTimelimitvld();

                  }else{
                    // 活动为空，直接赋值给Coplist，页面获取Coplist.length == 0 则渲染 “暂无相关活动”
                    that.setData({
                      Coplist: res.return_data.copList,
                      copShowlist: "false"
                    })
                  }

                }else{

                  that.setData({
                    copShowlist: "false"
                  })
                  wx.showModal({
                    content: res.return_msg,
                    showCancel: false,		//是否显示取消按钮
                    cancelColor:'skyblue',		//取消文字的颜色
                    confirmText:"确认",		//默认是“确定”
                    confirmColor: 'skyblue',	//确定文字的颜色
                  })

                }
              }
            )
          }
          // 可购券列表
          else if(that.data.echmodid == '05'){
            // Api请求：[微服务] 优惠券活动-echcopac：004-会员可【支付购买】优惠券列表查询
            Request_post.post(
              config.domainName+"api_echcopact/buycopact-list",
              {
                copcltid: config.copcltid,
                copchtid: that.data.copchtid,
                mbrparams: _mbrparams
              },
              function(res){
                // console.log(res)
                if(res != 'undefined' && res.return_no == 1 ){ 
                  if( res.return_data.copList.length > 0 ){
                    // console.log(res)
                    // 判断是否需要缓存下载，同时增加页面渲染的imgpath属性
                    if(App.globalData.Erpimage_Locstr ==='y'){
                      console.log('图片缓存到本地')
                      //将回调结果中的imgurl地址，转换为域名（原地址为：http://ip:port/xxx 转换为：https://域名/xxx）
                      let array = res.return_data.copList
                      for(var i in array){
                        if(array[i].logo){
                          array[i].logo = config.domainName + array[i].logo.split('/').slice(3).join('/');
                        }
                      }
                      // 调用本地文件缓存方法 mapCacheUrl
                      that.setData({
                        AvailableArray:array.map(i => ({
                          ...i,
                          imgpath:cacheimg.mapCacheUrl(i.logo)
                        }))  
                      }) ;
                    }else{
                      // 使用res的原始回调（数组对象中增加一个imgpath的属性值，因为html标签中用imgpath做渲染）
                      that.setData({
                        AvailableArray:res.return_data.copList.map(i => ({
                          ...i,
                          imgpath:i.logo
                        }))  ,
                      })
                    }
                    // console.log(that.data.AvailableArray)

                    // 循环判断当前会员的使用门槛金额，并重构数组
                    const AvailablecopArray = that.data.AvailableArray
                    AvailablecopArray.forEach(item => {
                      item.startuseamt = item.cusscpList.find(i=> i.cusscpid == App.globalData.mbrclsid).usestdamt
                    });
                    that.setData({Coplist:AvailablecopArray})

                    // 根据券性质copchtid 赋值config/GlobalArray.js中的主题颜色 Begin
                    const List = that.data.Coplist
                    const style = wxGloalArray.copstyle
                    for(var i = 0; i < List.length; i++){
                      for(var e = 0; e < style.length; e++){
                        if(style[e].copchtid == List[i].copchtid){   // 券性质（01-抵用券、02-兑换券、09-定额停车券、10-时长停车券）
                          for(var key in style[e]){			             // 将style数组中的第n个对象的所有属性(值)添加到coparray数组的第i个对象中。
                            List[i][key] = style[e][key]
                          }
                        }
                      } 
                    }
                    that.setData({
                      Coplist:List,
                      copShowlist: "false"
                    })

                    //发券效期时段、的数据绑定逻辑处理
                    that.copTimelimitvld();

                    

            
                  }else{
                    // 活动为空，直接赋值给Coplist，页面获取Coplist.length == 0 则渲染 “暂无相关活动”
                    that.setData({
                      Coplist: res.return_data.copList,
                      copShowlist: "false"
                    })
                  }

                }else{
                  that.setData({
                    copShowlist: "false"
                  })
                  wx.showModal({
                    content: res.return_msg,
                    showCancel: false,		//是否显示取消按钮
                    cancelColor:'skyblue',		//取消文字的颜色
                    confirmText:"确认",		//默认是“确定”
                    confirmColor: 'skyblue',	//确定文字的颜色
                  })

                }
              }
            )
          }
        }
        
      })

    })

    

  },



  // 优惠券列表时效计算方法——被调用
  copTimelimitvld:function(){
    var that = this
    // --------------------------------------- 发券效期时段、的数据绑定逻辑处理 begin--------------------------------------- //
    var Coplist = that.data.Coplist
    var getnowDateTime = todayDatetTime.getNowDateTime()      //当前日期时间：yyyy-mm-dd hh:mm:ss
    var getTime = getnowDateTime.substring(11,19)             //当前日期时间：hh:mm:ss
    var getDayNumber = getnowDateTime.substring(8,10)         //当前是几号：mm
    var getWeek = getNowWeek.getNowWeek()                     //当前是周几：周一、周二、....周七
    var today = getToday.getToday()                           //获取当天的日期 yyyy-mm-dd
    var NextMonth = getNextMonth.getNextMonth(today)
    var tomorrow = getTomorrow.getTomorrow()

    for(var i in Coplist){
      Coplist[i].showstyle = 'Default'          // 列表样式动态改变的标志（Default：普通模式；Reminder：提示模式），默认 Default    
      Coplist[i].Reminder_mode = ''             // 提醒模式，默认'' (countDown-倒计时、nextRound：下轮提醒)
      Coplist[i].rulechVldmode = ''             // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
      Coplist[i].toEndtimeGoing = 0             // 券列表对象增加： 当前有效活动的【倒计时】，默认 0 
      Coplist[i].rulrestValid = ''              // 券列表对象增加： 本日剩余时段是否还有有效规则，默认""
      Coplist[i].Cycle = 'valid'                // 券列表对象增加： 限领模式——下一限领周期是否有效（明日||次月 是否还在发券有效期内）默认：valid-有效、invalid-无效
      Coplist[i].rul_totalvldqty = Coplist[i].maxechqty - Coplist[i].rul_sumqty //规则单可获取的剩余总量

      // 限领方式：为02-每日限领、03-每月限领 的，判断明日 || 次月  即：下一个周期Cycle 的活动是否还有效
      if(Coplist[i].maxechtimesmodid == '02'){
        if(tomorrow <= formatDate.DateFormat(Coplist[i].disdat)){ //明日 <= 截至日期
          Coplist[i].Cycle = 'valid'
        }else{
          Coplist[i].Cycle = 'invalid'
        }
      }else if(Coplist[i].maxechtimesmodid == '03'){ 
        var thisMonth = formatDate.DateFormat(Coplist[i].disdat).substring(0,7)  //本月：YYYY-MM
        var nextMonth = formatDate.DateFormat(today).substring(0,7)              //结束月份：YYYY-MM
        if(thisMonth <= nextMonth){                               //次月 <= 截至日期月份
          Coplist[i].Cycle = 'valid'
        }else{
          Coplist[i].Cycle = 'invalid'
        }
      }

      // 显示控制：提醒模式   &&   发券日期：无限制
      if(Coplist[i].vldechdistypid == '01' && Coplist[i].drtechdattypid == '01'){  
        // 全时段有效
        if(Coplist[i].drtechtim == '00:00:00-23:59:59' ){
          var disdatStamp = timeTostamp.timeTostamp(formatDate.DateFormat(Coplist[i].disdat+'235959'))        
          var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)
          Coplist[i].toEndtimeGoing = intervalTime.intervalTime(todayNowStamp,disdatStamp) 
          Coplist[i].Reminder_mode = 'countDown'
          Coplist[i].showstyle = 'Reminder'
          Coplist[i].rulechVldmode = 'now'          // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
        }
        // 多时段
        if(Coplist[i].drtechtim != '00:00:00-23:59:59' ){
          for(var e in Coplist[i].drtechtiminfo){
            var todayBtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[e].btime)  
            var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[e].etime)      
            var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)
            // 本日-当前时段有效
            if(todayNowStamp >= todayBtimeStamp && todayNowStamp < todayEtimeStamp){    
              // console.log('本日-当前时段有效')
              Coplist[i].toEndtimeGoing = intervalTime.intervalTime(todayNowStamp,todayEtimeStamp) 
              Coplist[i].showstyle = 'Reminder'
              Coplist[i].Reminder_mode = 'countDown'    // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
              Coplist[i].rulechVldmode = 'now'          // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
              break;   //发现有效即终止
            //本日-当前时段无效
            }else{  
              // 本日还有剩余的有效时段
              if(todayNowStamp < todayBtimeStamp && todayNowStamp < todayEtimeStamp){
                Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[e].btime
                Coplist[i].showstyle = 'Reminder'
                Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                Coplist[i].rulechVldmode = 'today'          // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                break;  //发现有效即终止
              }else if(todayNowStamp > todayBtimeStamp && todayNowStamp > todayEtimeStamp){
                // 发券方式：无限制，如果本日已无有效时段，则预告的是【明日】的第一个活动
                const tomorrow = getTomorrow.getTomorrow()
                Coplist[i].nextRound_btime = tomorrow+" "+Coplist[i].drtechtiminfo[0].btime
                Coplist[i].showstyle = 'Reminder'
                Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                Coplist[i].rulechVldmode = 'tomorrow'       // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                // break;  //判断今日的时段全部无效，不能终止循环，必须循环所有对象值，比如，当前时间是 10:00:00   而 多个段的第一个时段是 08:00:00 - 08:30:00,这样就满足了所谓的当前时间 大于开始时段 && 大于截止时段，就会被判断为今日的已全部无效，
              }    
            }
          }
        }
      }


      

      // 显示控制：提醒模式   &&   发券日期：按星期（New）
      if(Coplist[i].vldechdistypid == '01' && Coplist[i].drtechdattypid == '02'){  
        // 星期全时段
        if(Coplist[i].drtechtim == '00:00:00-23:59:59' ){
          //本日全时段有效（New）
          for(var w in Coplist[i].drtechdatinfo){
            var getDayWeekNum = parseInt(weekTonumber.weekTonumber(getNowWeek.getNowWeek()))
            var echWeekNum = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[w]))
            //本日的星期值有效
            if(getDayWeekNum == echWeekNum){
              var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+'23:59:59')      
              var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)
              Coplist[i].toEndtimeGoing = intervalTime.intervalTime(todayNowStamp,todayEtimeStamp) 
              Coplist[i].showstyle = 'Reminder'
              Coplist[i].Reminder_mode = 'countDown'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
              Coplist[i].rulechVldmode = 'now'            // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
              break;
            }
            //本日的星期值无效，则轮询下个有效的星期值（本轮还有剩余星期）
            if(getDayWeekNum != echWeekNum && w == Coplist[i].drtechdatinfo.length -1){ 
              var thisWeekMaxValue = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1])) //获取本月的最大有效星期值
              
              for(var z in Coplist[i].drtechdatinfo){
                var getDayWeekNum = parseInt(weekTonumber.weekTonumber(getNowWeek.getNowWeek()))      //本日的星期值
                var echweek = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[z]))     //接口的星期值
                if(echweek > getDayWeekNum){
                  Coplist[i].nextRound_date = '本'+Coplist[i].drtechdatinfo[z]
                  Coplist[i].nextRound_btime = '00:00:00'
                  Coplist[i].nextRound_etime = '23:59:59'
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                  Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  break;
                }
              }
              //本日的星期值无效，则轮询下个有效的星期值（本轮无剩余星期）
              if(thisWeekMaxValue <= getDayWeekNum){
                Coplist[i].nextRound_date = '下'+Coplist[i].drtechdatinfo[0]
                Coplist[i].nextRound_btime = '00:00:00'
                Coplist[i].nextRound_etime = '23:59:59'
                Coplist[i].showstyle = 'Reminder'
                Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                break;
              }
            }
          }
        }

        // 星期多时段（New）
        if(Coplist[i].drtechtim != '00:00:00-23:59:59'){
          w:for(var w in Coplist[i].drtechdatinfo){     //循环领券的星期值
            var getDayWeekNum = parseInt(weekTonumber.weekTonumber(getNowWeek.getNowWeek()))      //本日的星期值
            var echWeekNum = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[w]))     //接口的星期值
            // 本日所属的星期值有效（三种可能：当前有效 + 当前时段无效，剩余时段有效 + 本日已无有效时段）
            if(getDayWeekNum == echWeekNum){
              for(var t in Coplist[i].drtechtiminfo){   //循环领券的时段值
                var todayBtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].btime)  //本日日期 + 开始时段
                var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].etime)  //本日日期 + 截止时段    
                var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)                                 //现在的日期+时段
                // 本日当前时段有效 ( 当前时段 >= 某规则开始时段 && 当前时段 < 某规则截止时段 )
                if(todayNowStamp >= todayBtimeStamp && todayNowStamp < todayEtimeStamp){ 
                  Coplist[i].toEndtimeGoing = intervalTime.intervalTime(todayNowStamp,todayEtimeStamp) 
                  Coplist[i].Reminder_mode = 'countDown'
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].rulechVldmode = 'now'  // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  break w;      //终止w循环
                }
              } 

              for(var t in Coplist[i].drtechtiminfo){   //循环领券的时段值
                var todayBtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].btime)  //本日日期 + 开始时段
                var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].etime)  //本日日期 + 截止时段    
                var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)                                 //现在的日期+时段
                // 本日当前时段无效,剩余时段有效 ( 当前时段 < 某规则开始时段 && 当前时段 < 某规则截止时段 )
                if(todayNowStamp < todayBtimeStamp && todayNowStamp < todayEtimeStamp){ 
                  Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[t].btime
                  Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[t].etime
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].Reminder_mode = 'nextRound'
                  Coplist[i].rulechVldmode = 'today'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  Coplist[i].rulrestValid = 'y'
                  break w;
                }
              } 
             
              for(var t in Coplist[i].drtechtiminfo){   //循环领券的时段值
                var todayBtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].btime)  //本日日期 + 开始时段
                var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].etime)  //本日日期 + 截止时段    
                var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)                                 //现在的日期+时段
                // 本日已无有效时段,轮询后面的有效星期、有效开始时间 ( 当前时段 > “所有”开始时段 && 当前时段 > “所有”所有截止时段 )
                if(todayNowStamp > todayBtimeStamp && todayNowStamp > todayEtimeStamp){
                  var thisWeekMaxValue = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1])) //获取本月的最大有效星期值
                  // 本日是有效的日期值，本日已无有效时段，但本日后还有有效的日期值+时段
                  for(var z in Coplist[i].drtechdatinfo){
                    var getDayWeekNum = parseInt(weekTonumber.weekTonumber(getNowWeek.getNowWeek()))      //本日的星期值
                    var echweek = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[z]))     //接口的星期值
                    if(echweek > getDayWeekNum){
                      Coplist[i].nextRound_date = '本'+Coplist[i].drtechdatinfo[z]
                      Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[0].btime
                      Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[0].etime
                      Coplist[i].showstyle = 'Reminder'
                      Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                      Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                      break w;
                    }
                  }
                }
              }
              
              var thisWeekMaxValue = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1])) //获取本月的最大有效星期值
              
              // 本日是有效的星期值，本日已无有效时段，且本日后也没有有效星期值（周一 至 周日），只能从 [星期值数组] 的第一个有效星期值取值（直接判断最大值 <= 当天的日期，不用循环）
              if(thisWeekMaxValue <= getDayWeekNum){
                Coplist[i].nextRound_date = '下'+Coplist[i].drtechdatinfo[0]
                Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[0].btime
                Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[0].etime
                Coplist[i].showstyle = 'Reminder'
                Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                break w;
              }
              
            }
            // 本日所属的星期值无效，则寻找下一个有效的活动（两种可能：本日所属星期无效但本周还有有效星期值、本日所属星期值无效，且本周已无有效星期——需要找下个星期的第一个有效日期）
            if(getDayWeekNum != echWeekNum && w == Coplist[i].drtechdatinfo.length -1){  //这个if必须等上面的if在循环体内全部判断完后，再执行
              var thisWeekMaxValue = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1])) //获取本月的最大有效星期值
              console.log(Coplist[i].drtechdatinfo.length -1)
              console.log(Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1])
              console.log(thisWeekMaxValue)
              // 本日不是有效的星期值，但本日后还有有效的星期值+时段
              for(var z in Coplist[i].drtechdatinfo){
                var getDayWeekNum = parseInt(weekTonumber.weekTonumber(getNowWeek.getNowWeek()))      //本日的星期值
                var echweek = parseInt(weekTonumber.weekTonumber(Coplist[i].drtechdatinfo[z]))     //接口的星期值
                if(echweek > getDayWeekNum){
                  Coplist[i].nextRound_date = '本'+Coplist[i].drtechdatinfo[z]
                  Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[0].btime
                  Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[0].etime
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                  Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  break w;
                }
              }
              // 本日不是有效的星期值，且本日后也没有有效星期值（周一 至 周日），只能从 [星期值数组] 的第一个有效星期值取值（直接判断最大值 < 当天的日期，不用循环）
              if(thisWeekMaxValue <= getDayWeekNum){
                Coplist[i].nextRound_date = '下'+Coplist[i].drtechdatinfo[0]
                Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[0].btime
                Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[0].etime
                Coplist[i].showstyle = 'Reminder'
                Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                break w;
              }
            }
          }
        }
      }


      // 显示控制：提醒模式   &&   发券日期：按日期（New）
      if(Coplist[i].vldechdistypid == '01' && Coplist[i].drtechdattypid == '03'){  
        // 日期全时段
        if(Coplist[i].drtechtim == '00:00:00-23:59:59' ){
          //本日全时段有效（New）
          for(var d in Coplist[i].drtechdatinfo){
            var echdayNum = parseInt(Coplist[i].drtechdatinfo[d])
            var getDayNumber = parseInt(TwoStringToNumbser.TwoStringToNumbser(getnowDateTime.substring(8,10)))
            //本日的日期值有效
            if(getDayNumber == echdayNum){
              var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+'23:59:59')      
              var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)
              Coplist[i].toEndtimeGoing = intervalTime.intervalTime(todayNowStamp,todayEtimeStamp) 
              Coplist[i].showstyle = 'Reminder'
              Coplist[i].Reminder_mode = 'countDown'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
              Coplist[i].rulechVldmode = 'now'            // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
              break;
            }
            //本日的日期值无效，则寻找下个有效的日期值
            if(getDayNumber != echdayNum && d == Coplist[i].drtechdatinfo.length -1){ 
              var thisdaysMaxValue = Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1] //获取每轮最大有效日期值
              for(var z in Coplist[i].drtechdatinfo){
                var echday = parseInt(Coplist[i].drtechdatinfo[z])
                if(echday > getDayNumber){
                  Coplist[i].nextRound_date = '本月'+Coplist[i].drtechdatinfo[z]+"日"
                  Coplist[i].nextRound_btime = '00:00:00'
                  Coplist[i].nextRound_etime = '23:59:59'
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                  Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  break;
                }
              }
              if(thisdaysMaxValue <= getDayNumber){
                Coplist[i].nextRound_date = '下月'+Coplist[i].drtechdatinfo[0]+"日"
                Coplist[i].nextRound_btime = '00:00:00'
                Coplist[i].nextRound_etime = '23:59:59'
                Coplist[i].showstyle = 'Reminder'
                Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                break;
              }
            }
          }
        }

        // 日期多时段（New）
        if(Coplist[i].drtechtim != '00:00:00-23:59:59'){
          w:for(var d in Coplist[i].drtechdatinfo){     //循环领券的日值
            var echdayNum = parseInt(Coplist[i].drtechdatinfo[d])
            var getDayNumber = parseInt(TwoStringToNumbser.TwoStringToNumbser(getnowDateTime.substring(8,10)))
            // 本日所属的日期值有效（三种可能：当前有效 + 当前时段无效，剩余时段有效 + 本日已无有效时段）
            if(getDayNumber == echdayNum){ 
              for(var t in Coplist[i].drtechtiminfo){   //循环领券的时段值
                var todayBtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].btime)  //本日日期 + 开始时段
                var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].etime)  //本日日期 + 截止时段    
                var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)                                 //现在的日期+时段
                // 本日当前时段有效 ( 当前时段 >= 某规则开始时段 && 当前时段 < 某规则截止时段 )
                if(todayNowStamp >= todayBtimeStamp && todayNowStamp < todayEtimeStamp){ 
                  // console.log('本日当前时段有效') 
                  Coplist[i].toEndtimeGoing = intervalTime.intervalTime(todayNowStamp,todayEtimeStamp) 
                  Coplist[i].Reminder_mode = 'countDown'
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].rulechVldmode = 'now'  // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  break w;      //终止w循环
                }
              }
              for(var t in Coplist[i].drtechtiminfo){   //循环领券的时段值
                var todayBtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].btime)  //本日日期 + 开始时段
                var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].etime)  //本日日期 + 截止时段    
                var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)                                 //现在的日期+时段
                // 本日当前时段无效，剩余时段有效 ( 当前时段 < 某规则开始时段 && 当前时段 < 某规则截止时段 )
                if(todayNowStamp < todayBtimeStamp && todayNowStamp < todayEtimeStamp){ 
                  // console.log('本日当前时段无效,当前时段无效，剩余时段有效')
                  Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[t].btime
                  Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[t].etime
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].Reminder_mode = 'nextRound'
                  Coplist[i].rulechVldmode = 'today'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  Coplist[i].rulrestValid = 'y'
                  break w;
                }
              }
              // 本日是有效的日期值,但本日已无有效时段,但本日后还有有效的日期值+时段
              for(var t in Coplist[i].drtechtiminfo){   //循环领券的时段值
                var todayBtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].btime)  //本日日期 + 开始时段
                var todayEtimeStamp = timeTostamp.timeTostamp(today+" "+Coplist[i].drtechtiminfo[t].etime)  //本日日期 + 截止时段    
                var todayNowStamp = timeTostamp.timeTostamp(getnowDateTime)                                 //现在的日期+时段
                if(todayNowStamp > todayBtimeStamp && todayNowStamp > todayEtimeStamp){
                  var thisdaysMaxValue = parseInt(Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1]) //获取本月的最大有效日期值
                  for(var z in Coplist[i].drtechdatinfo){
                    var echday =  parseInt(Coplist[i].drtechdatinfo[z])
                    if(echday > getDayNumber){
                      Coplist[i].nextRound_date = '本月'+Coplist[i].drtechdatinfo[z]+"日"
                      Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[0].btime
                      Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[0].etime
                      Coplist[i].showstyle = 'Reminder'
                      Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                      Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                      break w;
                    }
                  }
                }
                // 本日是有效的日期值，本日已无有效时段，且本日后也没有有效日期值（日期数组的最大一天），只能从 [日期值数组] 的第一个有效日期值取值（直接判断最大值 < 当天的日期，不用循环）
                var thisdaysMaxValue = parseInt(Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1]) //获取本月的最大有效日期值
                if(thisdaysMaxValue <= getDayNumber){
                  Coplist[i].nextRound_date = '下月'+Coplist[i].drtechdatinfo[0]+"日"
                  Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[0].btime
                  Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[0].etime
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                  Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  break w;
                }
              }
            } 
            // 本日所属的日期值无效，则寻找下一个有效的活动（两种可能：本日所属日期无效但本月还有有效日期值，本日所属日期值无效但本月已无有效星期——需要找下个月的第一个有效日期）
            if(getDayNumber != echdayNum && d == Coplist[i].drtechdatinfo.length -1){  //这个if必须等上面的if在循环体内全部判断完后，再执行
              var thisdaysMaxValue = parseInt(Coplist[i].drtechdatinfo[Coplist[i].drtechdatinfo.length -1]) //获取本月的最大有效日期值
              // 本日不是有效的日期值，但本日后还有有效的日期值+时段
              for(var z in Coplist[i].drtechdatinfo){
                var echday = parseInt(Coplist[i].drtechdatinfo[z])
                if(echday > getDayNumber){
                  Coplist[i].nextRound_date = '本月'+Coplist[i].drtechdatinfo[z]+"日"
                  Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[0].btime
                  Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[0].etime
                  Coplist[i].showstyle = 'Reminder'
                  Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                  Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                  break w;
                }                      
              }
              // 本日不是有效的日期值，且本日后也没有有效日期值（日期数组的最大一天），只能从 [日期值数组] 的第一个有效日期值取值（直接判断最大值 < 当天的日期，不用循环）
              if(thisdaysMaxValue <= getDayNumber){
                Coplist[i].nextRound_date = '下月'+Coplist[i].drtechdatinfo[0]+"日"
                Coplist[i].nextRound_btime = Coplist[i].drtechtiminfo[0].btime
                Coplist[i].nextRound_etime = Coplist[i].drtechtiminfo[0].etime
                Coplist[i].showstyle = 'Reminder'
                Coplist[i].Reminder_mode = 'nextRound'      // 提醒模式，默认'' (countDown-倒计时、nextRound-下轮提醒)
                Coplist[i].rulechVldmode = 'future'         // 规则有效模式，默认"" (now-当前有效、today-本日剩余有效、tomorrow-明日有效、future-未来有效、invalid-无效)
                break w;
              }
            }
          }
        }
      }
  
    } //循环券列表


    that.setData({
      Coplist,
    })
    // console.log(that.data.Coplist)
    // --------------------------------------- 发券效期时段、的数据绑定逻辑处理 end--------------------------------------- //
    
  },


  //倒计时归零后，都调用一下onShow方法，刷新列表页面
  finished:function(){
    this.onShow()
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {

  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {

  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: function () {

  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: function () {

  }
})


